package com.chuangmei.com.arindoorlocationsystem.utils;

import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.support.v4.content.FileProvider;
import android.text.TextUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by luohao on 2016/8/30.
 */
public class FileUtils {
    /**
     * 判断文件是否存在
     */
    public static boolean fileExists(String path) {
        if (TextUtils.isEmpty(path))
            return false;
        File file = new File(path);
        if (file.exists()&&file.isFile()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断文件夹是否存在
     */
    public static boolean dirExists(String path) {
        if (TextUtils.isEmpty(path))
            return false;
        File file = new File(path);
        if (file.exists() && file.isDirectory()) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean dirIsNull(String path) {
        File file = new File(path);
        if (file.isDirectory() && file.list().length > 0) {
            return false;
        }
        return true;
    }

    /**
     * 判断地址是文件还是文件夹
     *
     * @param path
     * @return
     */
    public static String isFileOrDir(String path) {
        if (TextUtils.isEmpty(path))
            return null;
        File file = new File(path);
        if (file.exists()) {
            if (file.isFile()) {
                return "file";
            } else if (file.isDirectory()) {
                return "dir";
            }
            return null;
        } else {
            return null;
        }
    }

    /**
     * 获取文件大小格式化字符串
     *
     * @param length
     * @return
     */
    public static String getFilesizeFormat(double length) {
        String sizestring = null;
        if (length > Math.pow(1024, 3)) { //大于1GB
            length = length / Math.pow(1024, 3);
            sizestring = DataUtils.DecimalD(length, 2) + "GB";
        } else if (length > Math.pow(1024, 2)) { //大于1MB
            length = length / Math.pow(1024, 2);
            sizestring = DataUtils.DecimalD(length, 2) + "MB";
        } else if (length > 1024) { //大于1kB
            length = length / 1024;
            sizestring = DataUtils.DecimalD(length, 2) + "KB";
        } else {
            sizestring = length + "K";
        }
        return sizestring;
    }

    /**
     * 读取文件
     */
    public static String readFileContent(String filePath) {
        StringBuffer sb = new StringBuffer();
        File file = new File(filePath);
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line = "";
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    /**
     * 得到文件或文件夹名
     *
     * @param file_path
     * @return
     */
    public static String getFileOrDirName(String file_path) {
        String fileName = null;
        if (fileExists(file_path)) {
            String[] split = file_path.split("/");
            //            if (isFileOrDir(file_path).equals("file")) {
            fileName = split[split.length - 1];//得到图集名
            //            } else if (isFileOrDir(file_path).equals("dir")) {
            //                fileName = split[split.length - 2];
            //            }
        }
        return fileName;
    }

    /**
     * 向文件中写入数据
     */
    public static String FileToWrite(String dir, String fileName, String string) {
        String temp = dir + "/" + fileName;
        //        LogUtils.debug("qqqqq"+dir);
        File file = new File(dir);
        if (!file.exists()) {
            file.mkdirs();
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(temp);
            fos.write(string.getBytes());
            fos.close();
            return temp;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 向临时文件中写入数据
     */
    public static String tempFileToWrite(String fileName, String string) {
        String temp = Constant.dir_temp + "/" + fileName;
        File file = new File(temp);
        if (!file.exists()) {
            file.mkdirs();
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(temp);
            fos.write(string.getBytes());
            fos.close();
            return temp;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    //根据路径获取所有文件
    public static List<File> getFiles(String path) {
        List<File> files = new ArrayList<File>();
        for (File f : new File(path).listFiles()) {
            if (f.isFile()) {
                files.add(f);
            }
        }
        return files;
    }

    //根据路径获取所有文件夹
    public static List<File> getDirectorys(String path) {
        List<File> files = new ArrayList<File>();
        for (File f : new File(path).listFiles()) {
            if (f.isDirectory()) {
                files.add(f);
            }
        }
        return files;
    }

    /**
     * 7.0以下打开系统文件管理器筛选mp4文件，7.0以上版本要在Application的onCreate中添加
     * <p>
     * if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
     * StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();
     * StrictMode.setVmPolicy(builder.build());}
     *
     * @param context
     * @param path
     */
    public static void openAssignFolder(Context context, String path) {
        File file = new File(path);
        if (null == file || !file.exists()) {
            return;
        }
        //获取父目录
        File parentFlie = new File(file.getParent());
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        //                intent.addCategory(Intent.CATEGORY_DEFAULT);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.setDataAndType(Uri.fromFile(parentFlie), "video/mp4");

        //        intent.addCategory(Intent.CATEGORY_OPENABLE);

        //        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        //        intent.putExtra("oneshot", 0);
        //        intent.putExtra("configchange", 0);
        //        intent.setDataAndType(Uri.fromFile(file), "video/mp4");
        try {
            //            context.startActivity(intent);
            context.startActivity(Intent.createChooser(intent, "选择浏览工具"));
        } catch (ActivityNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static void openAssignFolder2(Context context, String path) {
        Uri uri = FileProvider.getUriForFile(context, "com.chuangmei.com.arindoorlocationsystem.file_provider", new
                File(path));    //第二个参数是manifest中定义的`authorities`
        Intent intent = new Intent(Intent.ACTION_SEND);
        intent.setType("video/*");
        intent.putExtra(Intent.EXTRA_TITLE, "选择浏览工具");
        intent.putExtra(Intent.EXTRA_TEXT, "选择浏览工具dsds");
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);    //这一步很重要。给目标应用一个临时的授权。
        context.startActivity(intent);

    }


    //从resources中的raw 文件夹中获取文件并读取数据
    //    public static String getFromRaw(Context context, int resId) {
    //        String result = "";
    //        try {
    //            InputStream in = context.getResources().openRawResource(resId);//拿到资源得到一个输入流
    //            //获取文件的字节数
    //            int lenght = in.available();
    //            //创建byte数组
    //            byte[] buffer = new byte[lenght];
    //            //将文件中的数据读到byte数组中
    //            in.read(buffer);
    //            result = EncodingUtils.getString(buffer, "utf-8");
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    //        return result;
    //    }

    /**
     * 读取sd卡上指定后缀的所有文件
     *
     * @param files    返回的所有文件
     * @param filePath 路径(可传入sd卡路径)
     * @param suffere  后缀名称 比如 .gif
     * @return
     */
    public static List<File> getSuffixFile(List<File> files, String filePath, String suffere) {

        File f = new File(filePath);

        if (!f.exists()) {
            return null;
        }

        File[] subFiles = f.listFiles();
        for (File subFile : subFiles) {
            if (subFile.isFile() && subFile.getName().endsWith(suffere)) {
                files.add(subFile);
            } else if (subFile.isDirectory()) {
                getSuffixFile(files, subFile.getAbsolutePath(), suffere);
            } else {
                //非指定目录文件 不做处理
            }

        }

        return files;
    }

    /**
     * 从Resources复制文件到制定路径
     */
    public static void CopyFormResources(Context context, int resId, String tofile) {
        File dir = new File(tofile);
        if (dir.exists()) {
            dir.delete();
        }
        try {
            InputStream in = context.getResources().openRawResource(resId);
            FileOutputStream fos = new FileOutputStream(tofile);
            byte[] buffer = new byte[1024 * 8];
            int count = 0;
            while ((count = in.read(buffer)) > 0) {
                fos.write(buffer, 0, count);
            }
            fos.close();
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建文件目录
     */
    public static void CheckDir(String dir) {
        File f = new File(dir);
        if (!f.exists()) {
            f.mkdirs();
        }
    }

    /**
     * 删除文件
     */
    public static void delete(String path) {
        File file = new File(path);
        if (file.exists() == false) {
            return;
        }
        if (file.isFile()) {
            file.delete();
            return;
        }
        if (file.isDirectory()) {
            File[] childFiles = file.listFiles();

            for (int i = 0; i < childFiles.length; i++) {
                delete(childFiles[i].getPath());
            }
            file.delete();
        }
    }

    /**
     * 删除多文件
     */
    public static void deleteListFile(List<File> ListFile) {
        if (ListFile.size() > 0) {
            for (File file : ListFile) {
                if (file.exists()) {
                    delete(file.toString());
                }
            }
        } else {
            LogUtils.bugMes("无文件");
        }

    }

    /**
     * 删除数据库与缓存文件
     *
     * @param dbFile
     */
    public static void deleteDB(File dbFile) {
        dbFile.delete();
        String dbJournalPath = dbFile.toString() + "-journal";
        File journalFile = new File(dbJournalPath);
        if (dbFile.exists() && dbFile.isFile()) {
            dbFile.delete();
        }
        if (journalFile.exists() && journalFile.isFile()) {
            journalFile.delete();
        }
    }

    /**
     * 复制文件
     *
     * @param from
     * @param to
     * @return
     */
    public static boolean copy(String from, String to) {
        File srcFile = new File(from);
        File destFile = new File(to);
        if (srcFile.exists() && srcFile.isFile()) {
            // 判断目标文件是否存在
            if (destFile.exists()) {
                // 删除已经存在的目标文件，无论目标文件是目录还是单个文件
                new File(to).delete();
            }
            //判定父目录是否存在，不存在则创建
            File file = new File(destFile.getParent());
            if (!file.exists()) {
                file.mkdirs();
            }
        } else {
            return false;
        }
        // 复制文件
        int byteread = 0; // 读取的字节数
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream(srcFile);
            out = new FileOutputStream(destFile);
            byte[] buffer = new byte[1024];

            while ((byteread = in.read(buffer)) != -1) {
                out.write(buffer, 0, byteread);
            }
            return true;
        } catch (FileNotFoundException e) {
            return false;
        } catch (IOException e) {
            return false;
        } finally {
            try {
                if (out != null)
                    out.close();
                if (in != null)
                    in.close();
                return true;
            } catch (IOException e) {
                e.printStackTrace();
                return false;
            }
        }
    }

    /**
     * 得到同步shp图层的所有文件路径集合
     *
     * @return
     */
    public static List<File> getAllShpFile(String data_path) {
        List<File> shpFileList = new ArrayList<>();
        File file = new File(data_path);
        if (file.exists()) {
            File parentFile = file.getParentFile();//父路径
            File[] files = parentFile.listFiles();//父路径下的所有文件数组

            String noextFileName = CommonUtils.getFileName(data_path);
            //遍历父文件路径下的所有文件,其中包含文件名的File路径，将其删除
            for (File f : files) {
                if (f.isFile()) {
                    String nowName = CommonUtils.getFileName(f.getPath());
                    if (nowName.toLowerCase().equals(noextFileName.toLowerCase())) {
                        shpFileList.add(f);
                    }
                }
            }
        }
        return shpFileList;
    }

    /**
     * 得到文件名
     *
     * @param file 文件路径
     * @return
     */
    public static String getFileName(File file) {
        if (file.exists() && file.isFile()) {
            String fileName = file.getName();//原文件名
            return fileName.substring(0, fileName.indexOf("."));//截取字符串拿到无后缀文件名
        }
        return null;
    }

    /**
     * 重命名文件
     *
     * @param from
     * @param to
     * @return
     */
    public static boolean rename(String from, String to) {
        File srcFile = new File(from);
        if (srcFile.exists()) {
            File toFile = new File(to);
            if (toFile.exists()) {
                new File(to).delete();
            }
            return srcFile.renameTo(new File(to));
        } else {
            return false;
        }
    }

    /**
     * 文件重命名
     *
     * @param oldfile 原来的文件地址
     * @param newfile 新文件地址
     */
    public static boolean renameFile(File oldfile, File newfile) {

        if (!oldfile.exists()) {
            //重命名文件不存在
            return false;
        }
        if (newfile.exists()) {//若在该目录下已经有一个文件和新文件名相同，则不允许重命名
            LogUtils.bugMes(newfile + "已经存在！");
            newfile.delete();
            return oldfile.renameTo(newfile);
        } else {
            return false;
        }

    }


    /**
     * 保存字符串到文件
     *
     * @param path
     * @param content
     */
    public static void SaveTxt(String path, String content) {
        OutputStreamWriter pw = null;
        try {
            pw = new OutputStreamWriter(new FileOutputStream(path), "UTF-8");//确认流的输出文件和编码格式，此过程创建了“test.txt”
            pw.write(content);//将要写入文件的内容，可以多次write
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                pw.close();//关闭流
            } catch (Exception e) {

            }
        }
    }

    /**
     * 从文件中读取文本
     *
     * @param path
     * @return
     */
    public static String ReadTxt(String path) {
        String content = "";
        try {
            File file = new File(path);
            if (file.isFile() && file.exists()) { //判断文件是否存在
                InputStreamReader read = new InputStreamReader(
                        new FileInputStream(file), "UTF-8");//考虑到编码格式
                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                while ((lineTxt = bufferedReader.readLine()) != null) {
                    content += lineTxt;
                }
                read.close();
            } else {
                System.out.println("找不到指定的文件");
            }
        } catch (Exception e) {
            System.out.println("读取文件内容出错");
        }
        return content;
    }

    /**
     * 向文件中写入数据
     */
    public static void WriteTxt(String path, String content) {
        File file = new File(path);
        File fileParent = new File(file.getParent());
        if (!fileParent.exists()) {
            fileParent.mkdirs();
        }
        if (file.exists()) {
            file.delete();
        }
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            fos.write(content.getBytes());
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 追加文件：使用FileOutputStream，在构造FileOutputStream时，把第二个参数设为true
     *
     * @param file
     * @param conent
     */
    public static void zhuiJia(String file, String conent) {
        BufferedWriter out = null;
        try {
            out = new BufferedWriter(new OutputStreamWriter(
                    new FileOutputStream(file, true)));
            out.write(conent);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 读取一行文本
     *
     * @return
     */
    public static List<String> readFileOnLine(String strFileName) {
        FileInputStream fis = null;
        DataInputStream dataIO = null;
        List<String> lineString = new ArrayList<>();
        try {
            fis = new FileInputStream(strFileName);
            dataIO = new DataInputStream(fis);
            String strLine = null;
            while ((strLine = dataIO.readLine()) != null) {
                lineString.add(strLine);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                dataIO.close();
                fis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return lineString;
    }

    /**
     * 获取本地文件大小
     * 本地文件不存在，返回-1
     *
     * @param localPath
     * @return
     */
    public static long getFileLength(String localPath) {
        File f = new File(localPath);
        if (f.exists() && f.isFile()) {
            return f.length();
        } else {
            return -1;
        }
    }

    /**
     * 根据路径判断是否是文件
     *
     * @param localPath
     * @return
     */
    public static boolean isFile(String localPath) {
        if (TextUtils.isEmpty(localPath)) return false;
        File f = new File(localPath);
        if (f != null && f.exists() && f.isFile()) {
            return true;
        }
        return false;
    }

    /**
     * 根据路径判断是否是文件夹
     *
     * @param localPath
     * @return
     */
    public static boolean isDirectory(String localPath) {
        if (TextUtils.isEmpty(localPath)) return false;
        File f = new File(localPath);
        if (f != null && f.exists() && f.isDirectory()) {
            return true;
        }
        return false;
    }

    public static String getParent(String localPath) {
        if (TextUtils.isEmpty(localPath)) return null;
        File f = new File(localPath);
        if (f != null && f.exists()) {
            return f.getParent();
        }
        return null;
    }

}
